home *** CD-ROM | disk | FTP | other *** search
/ InfoMagic Internet Tools 1995 April / Internet Tools.iso / applic / ncsa / Mac / Telnet2.6 / prerelease / d4 / Telnet2.6.1d4.src.sit.hqx / Telnet 2.6.1d4 source / source / vr / vrrgmac.c < prev    next >
Encoding:
C/C++ Source or Header  |  1994-10-19  |  9.5 KB  |  411 lines
  1. /*
  2.  *
  3.  *      Virtual Graphics Kernel Macintosh Real Graphics Interface
  4.  *                          (rgmac.c)
  5.  *
  6.  *   National Center for Supercomputing Applications
  7.  *      by Gaige B. Paulsen
  8.  *
  9.  *    This file contains the macintosh real screen calls for the NCSA
  10.  *  Virtual Graphics Kernel.
  11.  *
  12.  *    Following are the Per Device calls:
  13.  *
  14.  *   MacRGraster( p,x1,y1,x2,y2,wid)- Plot raster in rect @(x1,y1,x2,y2) with wid @ p
  15.  *   MacRGcopy( x1,y1,x2,y2,x3,y3,x4,y4)- 
  16.  *   MacRGmap( offset,count,data)   - 
  17.  *
  18.  *
  19.  *  WARNING, WARNING!
  20.  *  Gaige has this cute idea about how to do "subwindows" of real windows by shifting
  21.  *  the window number by 4 bits (MAC_WINDOW_SHIFT).  Then, the remainder is the
  22.  *  sub-window number.  It will probably work, but you MUST keep the shifted and
  23.  *  non-shifted numbers straight.  For example, MacRGdestroy() and MacRGremove() take
  24.  *  different uses of the window number right now.  
  25.  *
  26.  *
  27.  *  Macintosh only Routines:
  28.  *
  29.  *      Version Date    Notes
  30.  *      ------- ------  ---------------------------------------------------
  31.  *        0.5     880912    Initial Coding -GBP
  32.  *      1.0     890216  Minor fixes for 1.0 - TKK
  33.  */
  34.  
  35. #ifdef MPW
  36. #pragma segment ICR
  37. #endif
  38.  
  39. #include "TelnetHeader.h"
  40.  
  41. #define __ALLNU__
  42. #include <Palettes.h>
  43. #include <Scrap.h>
  44.  
  45. #include <stdio.h>
  46. #include <string.h>
  47.  
  48. #include "maclook.proto.h"
  49. #include "vdevice.h"
  50. #include "vr.h"
  51. #include "InternalEvents.h"
  52. #include "telneterrors.h"
  53. #include "debug.h"
  54.  
  55. #define MAX_MAC_RGS    8
  56. #define MAX_MAC_SUB 16
  57. #define MAC_WINDOW_SHIFT    4        /* Bits shifted */
  58. #define    MAC_SUB_MASK    0xf            /* Bits maksed */
  59.  
  60. #include "vrrgmac.proto.h"
  61.  
  62. extern char *tempspot;
  63.  
  64. typedef struct MacWindow {
  65.     VDevice            vdev;            /* virtual device to draw in, has its own colors */
  66.     WindowPtr         window;            /* My Window  (0L if not in use ) */
  67.     PaletteHandle     palette;        /* My Palette */
  68.     char            title[256];        /* Title string */
  69.     
  70.     
  71.     Point            size;            /* My height and width */
  72.     Rect            subs[MAX_MAC_SUB];/* Rectangles of my subwindows [0,0,0,0] if not in use */
  73.     } MacWindow;
  74.  
  75. MacWindow *MacRGs;
  76.  
  77. short RGwn=0;                            /* Window number in use */
  78. short RGsub=0;                        /* Sub-Window Number in use */
  79.  
  80. void MacRGinit(void)
  81. {
  82.     short i;
  83.     
  84.     MacRGs= (MacWindow *)NewPtr( MAX_MAC_RGS * sizeof(MacWindow));
  85.     for (i=0;i<MAX_MAC_RGS;i++)
  86.         MacRGs[i].window=NULL;
  87. }
  88.  
  89. /************************************************************
  90.  * MacRGnewwindow( name, x1, y1, x2, y2)        -            *
  91.  *        make a new subwindow to wn                            *
  92.  ************************************************************/
  93.  
  94. short MacRGnewwindow
  95.   (
  96.     char *name,
  97.     short x1,
  98.     short y1,
  99.     short x2,
  100.     short y2
  101.   )
  102. {
  103.     short w,i ;
  104.     extern short RScolor;
  105.     Rect wDims;
  106.     register char *p;
  107.     RGBColor curcol;
  108.  
  109.     p = (char *)NewPtr(1000 + (x2-x1+5) *(y2-y1+5));
  110.     if (!p)         /* is there enough memory??? */
  111.         {            /* no memory, so let us know about it */
  112.         DoError(108 | MEMORY_ERRORCLASS, LEVEL2, NULL);        
  113.         return(-1);
  114.         }
  115.     else
  116.         DisposPtr(p);
  117.     
  118.     for (w=0; w<MAX_MAC_RGS && MacRGs[w].window; w++)
  119.         /* loop */;
  120.     
  121.     if (w>= MAX_MAC_RGS)
  122.         return( -1);
  123.         
  124.     if ((x2 - x1) & 1)                        /* odd width, must be even */
  125.         x2++;
  126.     
  127.     SetRect( &wDims,  x1+40, y1+40, x2+40, y2+40);
  128.         
  129.     strcpy( MacRGs[w].title, name);                        /* Copy of the name */
  130.     
  131.     if (!RScolor)        /* Borrow from RS */
  132.         return(-1);
  133. /*        MacRGs[w].window=NewWindow(0L, &wDims, name, TRUE, 4, -1L, TRUE, (long) w); */
  134.     else {
  135.         short i;
  136.         Str255    scratchPstring;
  137.         strcpy((char *)scratchPstring, name);
  138.         CtoPstr((char *)scratchPstring);
  139.         
  140.         MacRGs[w].window=NewCWindow(NULL, &wDims, scratchPstring, TRUE, noGrowDocProc, kInFront,    /* BYU LSC */
  141.             TRUE, (long) w);
  142.  
  143.  
  144.         MacRGs[w].vdev.bp  = (unsigned char *)NewPtr( (x2-x1+5) *(y2-y1+5));    /* BYU LSC */
  145.  
  146.         if (!MacRGs[w].vdev.bp) putln("Window has no bitmap...");
  147.         else {
  148.             SetRect(&MacRGs[w].vdev.bounds, 0,0, x2-x1, y2-y1);
  149.             InitVDevice(&MacRGs[w].vdev);        /* get vdevice going */
  150.         
  151.             MacRGs[w].palette = NewPalette( 256, NULL, pmTolerant, 0);
  152.             
  153.             for (i=0; i<256; i++) {                /* load with grey-scale */
  154.                 curcol.red = i<<8;
  155.                 curcol.green = i<<8;
  156.                 curcol.blue = i<<8;
  157.                 SetEntryColor( MacRGs[w].palette, i, &curcol);
  158.                 }
  159.             
  160.             SetPalette( MacRGs[w].window, MacRGs[w].palette, TRUE);
  161.             ActivatePalette( MacRGs[w].window);
  162.         
  163.             ColorVDevice(&MacRGs[w].vdev,MacRGs[w].palette);
  164.             }
  165.         }
  166.     
  167.  
  168.     if (!MacRGs[w].window)         /* couldnt open the real window */
  169.         {
  170.         DoError (302 | RESOURCE_ERRORCLASS, LEVEL2, NULL);
  171.         return(-2);
  172.         }
  173.     
  174.     ((WindowPeek)MacRGs[w].window)->windowKind = WIN_ICRG;    
  175.     MacRGs[w].size.h = x2-x1;
  176.     MacRGs[w].size.v = y2-y1;
  177.     for (i=0; i<MAX_MAC_SUB; i++)
  178.         SetRect( &MacRGs[w].subs[i], 0,0,0,0);            /* Reset the subs */
  179.     RGwn = w;
  180.     RGsub= 0;
  181.     return (w << MAC_WINDOW_SHIFT);
  182. }
  183.  
  184. /****************************************
  185.  * MacRGsubwindow(wn)        -            *
  186.  *        make a new subwindow to wn        *
  187.  ****************************************/
  188.  
  189. short MacRGsubwindow( short wn)
  190. {
  191.     return (wn);
  192. }
  193.  
  194. /****************************************
  195.  * MacRGsetwindow(wn)        -            *
  196.  *        set the drawing window to wn    *
  197.  ****************************************/
  198. void MacRGsetwindow( short wn)
  199. {
  200.     short w = wn >> MAC_WINDOW_SHIFT;
  201.     
  202.     if (!MacRGs[w].window)
  203.         return;
  204.     
  205.     SetPort( MacRGs[w].window);
  206.     RGwn = w;
  207.     RGsub= wn & MAC_SUB_MASK;
  208.     
  209.     /* Optionally set the clip region */
  210. }
  211.  
  212. /****************************************
  213.  * MacRGdestroy(wn)        -                *
  214.  *        destroy window wn                *
  215.  ****************************************/
  216. void MacRGdestroy(short wn)
  217. {
  218.     
  219. //    sprintf((char *) tempspot,"destroy: %d", wn); putln((char *) tempspot);    /* BYU LSC */
  220.     if (!MacRGs[wn].window)
  221.         return;
  222.     
  223.     VRdestroybyName((char *) &MacRGs[wn].title);
  224. }
  225.     
  226. /****************************************
  227.  * MacRGremove(wn)        -                *
  228.  *        destroy window wn                *
  229.  ****************************************/
  230. void MacRGremove
  231.   (
  232.     short wn
  233.   )
  234. {
  235.     CGrafPtr cgp;
  236.     short w = wn>> MAC_WINDOW_SHIFT;
  237.     
  238.     if (!MacRGs[w].window)
  239.         return;
  240.     
  241.     TrashVDevice(&MacRGs[w].vdev);
  242.     
  243.     if (MacRGs[w].vdev.bp) 
  244.         DisposPtr((Ptr)MacRGs[w].vdev.bp);
  245.     
  246.     cgp = (CGrafPtr) MacRGs[w].window;                    /* unseed window color table */
  247.     (*(*(cgp->portPixMap))->pmTable)->ctSeed = GetCTSeed();
  248.     
  249.     DisposeWindow( MacRGs[w].window);        /* Get rid of the actual window */
  250.  
  251.     if (MacRGs[w].palette)
  252.         DisposePalette( MacRGs[w].palette);
  253.         
  254.     MacRGs[w].palette = NULL;
  255.     MacRGs[w].window = NULL;
  256. //    sprintf((char *) tempspot,"take away: %d", w); putln((char *) tempspot);    /* BYU LSC */
  257. }
  258.  
  259. short MacRGfindwind(WindowPtr wind)
  260. {
  261.     short i=0;
  262.     
  263.     if (!wind)
  264.         return(-2);
  265.     
  266.     while (i<MAX_MAC_RGS && wind != MacRGs[i].window)
  267.         i++;
  268.     if (i==MAX_MAC_RGS)
  269.         return(-1);
  270.  
  271.     return( i);
  272. }
  273.  
  274. /************************************************************************************/
  275. /* MacRGcopy
  276. *  Copybits the image window into the clipboard.
  277. *  
  278. */
  279. RGBColor    icrwhite = { 0xffff,0xffff,0xffff },
  280.             icrblack = { 0,0,0}; 
  281.             
  282. void MacRGcopy(WindowPtr wind)
  283. {
  284.     Rect copysize,copyfrom;
  285.     long len,wn;
  286.     PicHandle picture;
  287.     CGrafPtr hidep;
  288.         
  289.     if (( wn= MacRGfindwind( wind)) <0)
  290.         return;                        /* Couldn't do it */
  291.  
  292.     hidep = &MacRGs[wn].vdev.vport;
  293.     copyfrom = MacRGs[wn].vdev.bounds;
  294.             
  295.     SetPort(wind);
  296.     
  297.     copysize = copyfrom;                        /* boundary of drawing area */
  298.  
  299.     picture= OpenPicture(©size);
  300.  
  301.     ClipRect(©size);
  302.     
  303. /*    RGBBackColor(&icrwhite);
  304.     RGBForeColor(&icrblack); */
  305.  
  306.     ForeColor( blackColor);
  307.     BackColor( whiteColor);
  308.     HLock((Handle) hidep->portPixMap);
  309.                 
  310.     CopyBits((BitMap *) (*(hidep->portPixMap)), &wind->portBits,
  311.             ©from, ©size, srcCopy, NULL); 
  312.             
  313.     HUnlock((Handle) hidep->portPixMap);
  314.  
  315.     ClosePicture();
  316.     
  317. /*    put the PICT into the scrap manager */
  318.     len = GetHandleSize((Handle) picture);
  319.     HLock((Handle) picture);
  320.     ZeroScrap();
  321.     PutScrap( len, 'PICT', (Ptr) *picture);
  322.     HUnlock((Handle) picture);
  323.     KillPicture(picture);
  324.  
  325. }
  326.  
  327. short MacRGupdate( WindowPtr wind)
  328. {
  329.     short wn;
  330.     Rect cbRect;
  331.     
  332.     if (( wn= MacRGfindwind( wind)) <0)
  333.         return(-1);                        /* Couldn't do it */
  334.  
  335.      SetPort(wind);
  336.     ForeColor( blackColor);
  337.     BackColor( whiteColor);
  338.     BeginUpdate(wind);
  339.         /* EraseRect( &wind->portRect); */
  340.         HLock((Handle) MacRGs[wn].vdev.vport.portPixMap);
  341.         cbRect = MacRGs[wn].vdev.bounds;
  342.         CopyBits((BitMap *) *MacRGs[wn].vdev.vport.portPixMap,&(wind->portBits), 
  343.             &cbRect,&cbRect, srcCopy, NULL);
  344.         HUnlock((Handle) MacRGs[wn].vdev.vport.portPixMap);
  345.     EndUpdate( wind);
  346.     return(0);
  347. }
  348.  
  349. /**************************** Hereafter lie the graphics routines ************************/
  350. short    MacRGraster(char *data, short x1, short y1, short x2, short y2, short rowbytes)
  351. {
  352.     Rect tr;
  353.     register char *p;
  354.     register short i;
  355.     
  356.     if (!MacRGs[RGwn].window)
  357.         return(-1);
  358.         
  359.     SetPort( MacRGs[ RGwn].window);
  360.     
  361.     if (MacRGs[RGwn].vdev.bp) {                /* If we have off-screen buffer */
  362.  
  363.         p = (char *) MacRGs[RGwn].vdev.bp + MacRGs[RGwn].size.h*y1 + x1;  /* start point */
  364.         for (i=0; i<rowbytes; i++)
  365.             *p++ = *data++;
  366.  
  367.         SetRect(&tr, x1,y1, x2+1,y2+1);
  368.         InvalRect(&tr);
  369.     }
  370.     
  371.     return(0);
  372. }
  373.  
  374. short    MacRGcopyrgn(short x1, short y1, short x2, short y2, short x3, short y3, short x4, short y4)
  375. {
  376.     UNUSED_ARG(x1)
  377.     UNUSED_ARG(y1)
  378.     UNUSED_ARG(x2)
  379.     UNUSED_ARG(y2)
  380.     UNUSED_ARG(x3)
  381.     UNUSED_ARG(y3)
  382.     UNUSED_ARG(x4)
  383.     UNUSED_ARG(y4)
  384.     /* copy one region to another within wn */
  385.     return 0;
  386. }
  387.  
  388. short    MacRGmap(short start, short length, char *data)
  389. {
  390.     short i;
  391.     RGBColor curcol;
  392.     
  393.     for (i=start; i<start+length; i++) {        
  394.         curcol.red = (*data++)<<8;
  395.         curcol.green = (*data++)<<8;
  396.         curcol.blue = (*data++)<<8;
  397.         SetEntryColor( MacRGs[RGwn].palette, i, &curcol);
  398.     }
  399.     
  400.     SetPalette( MacRGs[RGwn].window, MacRGs[RGwn].palette, TRUE);
  401.     ActivatePalette( MacRGs[RGwn].window);
  402.  
  403.     ColorVDevice(&MacRGs[RGwn].vdev,MacRGs[RGwn].palette);
  404. #if 0                                                            /* BYU LSC */
  405.     sprintf((char *) tempspot, "Palette[%d,%d]",start,length);    /* BYU LSC */
  406.     putln((char *) tempspot);                                    /* BYU LSC */
  407. #endif
  408.     return 0;
  409. }
  410.         
  411.